Each call to UIElement.InputHitTest(Point, out, out, out) allocated four
small heap objects: PointHitTestParameters, InputHitTestResult, and the
two callback delegates (filter + result). At ~60 Hz cursor movement across
a moderately deep visual tree, this fires ~5-50k times per scenario.

The 2026-05-11 deep-dive (autoresearch/deep-dive-2026-05-11/T1-point-allocations.md)
flagged this as the #1 contributor to the ~71 MB combined System.Windows.Point
allocation budget across take-open + playback — estimated savings 30-40 MB.

Three changes:
- The filter callback's body uses only the `currentNode` argument and static
  UIElementHelper helpers — no `this` capture. Make it `private static` and
  cache one shared HitTestFilterCallback delegate as a static readonly field.
- Cache a single PointHitTestParameters wrapper per thread via [ThreadStatic].
  PointHitTestParameters.SetHitPoint() (already internal) mutates the inner
  Point before each VisualTreeHelper.HitTest call.
- Add Acquire/Release pooling to the nested InputHitTestResult class. The
  HitTestResultCallback's delegate target IS the instance, so the pool stores
  the (instance, callback) pair to preserve binding across cycles. On rare
  nested reentrancy, Acquire falls back to a fresh instance — same single-slot
  pattern as the existing StreamGeometryCallbackContext pool. Result and
  HitTestResult are captured into locals BEFORE Release so the post-traversal
  iteration uses only stable values.

VisualTreeHelper.HitTest is synchronous and consumes the parameters during
traversal (no retention past return). The callbacks (filter + result) don't
reinvoke InputHitTest, so reentrancy within one traversal is impossible.
Reentrancy from the post-traversal contentHost.InputHitTest chain happens
AFTER Release — pool slot is repopulated by the time recursion would run.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Commit 7831813 ("wpf-perf(big-win T4): pool AdornerLayer._zOrderMap
value snapshot") shipped a per-instance object[] snapshot buffer
shared between MeasureOverride and ArrangeOverride to eliminate ~170 MB
of per-pass DictionaryEntry[] allocations during MotionCatalyst
take-open.

Defect: Adorner.Measure / Adorner.Arrange callouts can re-enter the
same AdornerLayer's MeasureOverride/ArrangeOverride via a nested layout
pass. A naïve shared field lets the inner call's CopyTo overwrite the
outer pass's snapshot, and its terminal Array.Clear nulls the slots
the outer is still iterating — the outer then reads a null reference
and the layout throws, leaving MotionCatalyst with a completely blank
canvas on take-open.

Fix: lease pattern. Each call captures the current field value into a
local, immediately nulls the field (so any re-entrant call allocates
its own buffer rather than aliasing), iterates on the local, and at
end of pass restores its buffer to the field — keeping whichever
buffer (own or the one a nested call left behind) is larger.

Steady state on the non-re-entrant path remains zero-allocation: the
field holds the grown buffer, every subsequent call leases-clears-
copies-iterates-clears-restores in place. Re-entrant calls pay one
object[] allocation per nesting level, matching the worst case of the
pre-7831813a baseline.

Validated end-to-end via MCP UI screenshots on MotionCatalyst:
  - HEAD before fix: take-open shows fully black canvas
  - HEAD + this fix: identical to vanilla upstream/release/10.0
    (Carl Hansen golf swing, Frame 0/1240, both video viewports
     rendered, Pressure & Stance heatmap, Launch Monitor, all data
     boxes populated, playback toggles cleanly)

All 358 perf commits in PRs #1-#4 preserved.